Internet Info 1994 March

home *** CD-ROM | disk | FTP | other *** search

/ Internet Info 1994 March / Internet Info CD-ROM (Walnut Creek) (March 1994).iso / networking / terms / kermit / a / msxhp1.asm < prev next >

Wrap

Assembly Source File | 1991-03-17 | 54.8 KB | 2,040 lines

name msxhp1 ; File MSXHP1.ASM include mssdef.h ; Copyright (C) 1982,1991, Trustees of Columbia University in the ; City of New York. Permission is granted to any individual or ; institution to use, copy, or redistribute this software as long as ; it is not sold for profit and this copyright notice is retained. ; System dependent module for HP150. ; Use with file MSUHP1.ASM (keyboard translator) ; Edit history ; 2 March 1991 version 3.10 ; Nov. 24, 1990. Remove references to prserr to make linker happy. ; Nov. 21, 1990. Dump capture buffer (cptdmp) when exiting connect mode. [jan] ; Sept. 1990. Read 20 characters a time from dcomm. Read keyboard ; once every 16 reads of dc port. Start port at 7 bits so firmware ; flow control works. Disable our own flow control. Now works at 4800 ; baud with no flow control. ; August 1990 update to 3.0. Incorporate tektronix. Add replay. [jan]. ; John Nyenhuis, Purdue University, School of Electrical Engineering ; West Lafayette, Indiana 47907 USA (317)494-3524 nyenhuis@ecn.purdue.edu ; 1 July 1988 Version 2.31 ; 11 Jan 1988 update to 2.30 consistency level. ; 1 Jan 1988 version 2.30 writechar macro saying pushf push dx push ax mov ah,2 mov dl,saying int dos pop ax pop dx popf endm writestring macro saying pushf push ax push dx mov ah,prstr mov dx,offset saying int dos pop dx pop ax popf endm saveregs macro push ax push bx push cx push dx push es push di push si push ds push bp pushf endm restoreregs macro popf pop bp pop ds pop si pop di pop es pop dx pop cx pop bx pop ax endm ;; below 40 publics are the minimum necessary public baudst, ihostr, bdtab, getbaud, chrout, pcwait, putmod public serrst, trnprs, prtchr, poscur, outchr, dtrlow, vts, puthlp public vtstat, coms, cquery, ctlu, shomodem, portval, getmodem public term, dumpscr, cmblnk, cquit, locate, clearl, machnam, lclini public sendbl, comptab, sendbr, clrmod, cstatus, termtb, serhng public clrbuf, beep, serini ;;additional system dependent publics public termtog, kclrscn, kdos, snull, cquit, cquery public toterminal, klogtog, setchtab, vtstbl false equ 0 true equ 1 instat equ 6 print_out equ 05h ; dos function to print to printer prtscr equ 80h ; print screen pressed wrdev equ 40H rddev equ 3fH open equ 3dH close equ 3eH rdchan equ 2 e_send_break equ 6 e_ioctl equ 44h ; DOS i/o control function passall equ 0803h ; Port transparency mode [WHM] xofcnt equ 32 ; number of characters to send xoff xoncnt equ 16 ; number of characters to send xon dos201 equ 201h dos211 equ 20bh ; dosnum for 2.11 data segment public 'data' extrn lclexit:word, flags:byte, trans:byte, dmpname:byte extrn kbdflg:byte, rxtable:byte, denyflg:word, repflg:byte extrn diskio:byte ; for replay feature extrn dosnum:word, agiosbuff:byte extrn sloghnd:word ; session log handle from msster extrn prnhand:word machnam db 'HP-150$' erms40 db cr,lf,'?Warning: Unrecognized baud rate$' erms41 db cr,lf,'?Warning: Cannot open com port$' noimp db cr,lf,'Command not implemented.$' hngmsg db cr,lf,' The phone should have hungup.',cr,lf,'$' hnghlp db cr,lf,' The modem control lines DTR and RTS for the current' db ' port are forced low (off)' db cr,lf,' to hangup the phone. Normally, Kermit leaves them' db ' high (on) when it exits.' db cr,lf,'$' msmsg1 db cr,lf,' Communications port is not ready.$' msmsg2 db cr,lf,' Communications port is ready.$' rdbuf db 80 dup (0) ; temp buf setktab db 0 setkhlp db 0 shkmsg db '?Not implemented.' shklen equ $-shkmsg anspflg db 0 ; printing active status crlf db cr,lf,'$' delstr db BS,BS,' ',BS,BS,'$' ; Delete string clrlin db cr,ESCAPE,'K$' xofsnt db 0 ; Say if we sent an XOFF xofrcv db 0 ; Say if we received an XOFF invseq db ESCAPE,'&dJ$' ; Reverse video nrmseq db ESCAPE,'&d@$' ; Normal mode ivlseq db 80 dup (' '),ESCAPE,'A','$' ; [ak] Make a line inverse video keydelay db 0 ; delay for keyboard reads tmp db 0,'$' temp dw 0 temp1 dw 0 temp2 dw 0 eightstatustxt db 'No. Bits: $' eightflg db eightbitnum transparencytxt db 'Port Status: $' transparentflg db transonnum rawtxt db 'Port Mode: $' rawflg db rawonnum tekstatustxt db 'Tek Auto Entry: $' tekbyte db tekonnum ; tek auto entry temp3 dw 0 ; structure for status information table sttab. stent struc sttyp dw 0 ; type (actually routine to call) msg dw 0 ; message to print val2 dw 0 ; needed value: another message, or tbl addr tstcel dw 0 ; address of cell to test, in data segment basval dw 0 ; base value, if non-zero stent ends ; table with datacomm status for the status command vtstbl stent <srchkw,eightstatustxt,termtb,eightflg> ; tell 7 or 8 bits stent <srchkw,transparencytxt,termtb,transparentflg> ; tell if transparent stent <srchkw,rawtxt,termtb,rawflg> ; tell if raw or cooked stent <srchkw,tekstatustxt,termtb,tekbyte> ; tell if raw or cooked dw 0 ; end of table ; Entries for choosing communications port comptab db 4 ; four entries mkeyw '1',1 mkeyw '2',2 mkeyw 'COM1',1 mkeyw 'COM2',2 port1 prtinfo <0FFFH,0,defpar,1,0,defhand,floxon,0> port2 prtinfo <0FFFH,0,defpar,1,0,defhand,floxon,0> portval dw port1 ; Default is to use port 1 bdtab db 9 ; baud rate table mkeyw '110',0 mkeyw '150',1 mkeyw '300',2 mkeyw '600',3 mkeyw '1200',4 mkeyw '2400',5 mkeyw '4800',6 mkeyw '9600',7 mkeyw '19200',8 ; mappings for baud settings from hp to our table ourbdtab db 0,0 ; not applicable db 1,0 ; na db 2,0 ; 110 db 3,0 ; na db 4,1 ; 150 db 5,2 ; 300 db 6,3 ; 600 db 7,4 ; 1200 db 8,0 ; na db 9,0 ; na db 10,5 ; 2400 db 11,0 ; na db 12,6 ; 4800 db 13,0 ; na db 14,7 ; 9600 db 15,8 ; 19200 ; mappings for baud setting from our table to hp ourbdtab1 db 0,2 ; 300 db 1,4 ; 150 db 2,5 ; 300 db 3,6 ; 600 db 4,7 ; 1200 db 5,10 ; 2400 db 6,12 ; 4800 db 7,14 ; 9600 db 8,15 ; 19200 setchtab db 1; set file character-set table mkeyw 'CP437',437 sevenbitnum equ 7 eightbitnum equ 8 transonnum equ 9 transoffnum equ 10 rawonnum equ 11 rawoffnum equ 12 tekonnum equ 13 tekoffnum equ 14 termtb db 10 ; entries for Status, not Set mkeyw 'HP150',ttgenrc mkeyw 'Tek4014',tttek mkeyw '7bit',sevenbitnum mkeyw '8bit',eightbitnum mkeyw 'OnTransparency',transonnum mkeyw 'OffTransparency',transoffnum mkeyw 'Raw',rawonnum mkeyw 'Cooked',rawoffnum mkeyw 'EnableTek',tekonnum mkeyw 'DisableTek',tekoffnum ; variables for serial interrupt handler source db bufsiz DUP(?) ; Buffer for data from port bufout dw 0 ; buffer removal ptr count dw 0 ; Number of chars in int buffer bufin dw 0 ; buffer insertion ptr telflg db 0 ; Are we acting as a terminal clreol db ESCAPE,'K$' prttab dw com1,com2 com1 db 'COM1',0 com2 db 'COM2',0 blank db ESCAPE,'H',ESCAPE,'J$' movcur db ESCAPE,'&a' colno db 20 dup (0) ten db 10 prthnd dw 0 argadr dw 0 ; address of arg blk from msster.asm parmsk db 0ffh ; 8/7 bit parity mask, for reception flowoff db 0 ; flow-off char, Xoff or null (if no flow) flowon db 0 ; flow-on char, Xon or null captrtn dw cptchr ; routine to call for captured output logflag db false ; if true, we are logging session ; (we have taken cptchr from msster and placed in ; in msxhp1 to avoid flow control problems) tempbuf dw 10 dup(0) ourarg termarg <> ;;new stuff to scan escape sequences from comm port [jan] stringtab dw tekst1,tekst2 ; strings for matching dw tekst3 numstrings equ 3 ; number of strings to match disptab dw toteknoplay,totekplay ; dispatch table dw leavetek dw ignoreall, ignoreall tekst1 db escape,'[?38h',0 ;1st string to get into tek mode [jan] tekst2 db escape,FF,0 ;2nd string to get into tek mode [jan] tekst3 db escape,'[?38l',0 ; string to exit tekmode stringchekbuff db 16 dup (0) stringchekcnt dw 0 ; characters already in buffer matchsofar dw false ; no match yet match dw 0 playem db false ; don't play back switch characters ; end of data for string scannine prtrdy db true ; if false, we get out of connect mode capbuf db cptsiz dup (0) ; session logging buffer capbp dw capbuf caplft dw cptsiz capterr db escape,'Error in writing log file ','$' alpha_disp db escape,'&s0P',escape,'&s0Q','$' ; alpha active tek_disp db escape,'&s1P',escape,'&s0Q',escape,'*t1D','$' ; tek active alpha_on db escape,'*dE','$' ; turn on alpha display alpha_off db escape,'*dF','$' ; turn off alpha display tek_on db escape,'*dC','$' ; turn on tek display tek_off db escape,'*dD','$' ; turn off tek display alpha_clear db escape,'H',escape,'J', '$' ; clear alpha tek_clear db escape,'*dA',escape,'*dL',escape,'*d0,380O','$'; clear tek to_term_msg db 'Entering Firmware terminal ' db 'Press SHIFT STOP to return to Kermit','$' ;;;; Data for reading data comm configuration in firmware ;******************************************* ; e_cnp_rom_segment equ 0000h e_cnp_entry equ 045ch e_dhp_entry equ 0425h e_dhp_driver equ 042ah e_long_call equ 09ah ; e_port1_read equ 2 e_port2_read equ 4 e_port1_save equ 2 e_port2_save equ 11 e_port1 equ 1 ; values for the two physcial ports. e_port2 equ 2 e_true equ 1 e_false equ 0 ; ;************** LOCAL DECLARATIONS ************** ; ; CONFIGURATION_DATA_AREA struc predef_values db ? barrel_index db ? dc_port db ? dc_bool1 db ? dc_bool2 db ? dc_baud_rate db ? dc_parity db ? dc_clock db ? dc_asterisk db ? dc_recv_pace db ? dev_token dw ? CONFIGURATION_DATA_AREA ends dc_status_struc struc ; status for datacomm eightbit db 0 ; true if 8 bit, false if 7 bit transparent db 0 ; true if transparent, false if not transparent raw db 0 ; true if raw, false if cooked dc_status_struc ends ; scratch space. ; err_flag db 0 readid dw 0 saveid dw 0 work_config CONFIGURATION_DATA_AREA <> dc_status dc_status_struc <true,true,true> ; ;************************************ ; ; Macros for absolute long calls. ; ;************************************ ; call_cnp_entry macro db e_long_call dw e_cnp_entry dw e_cnp_rom_segment endm call_dhp_entry macro db e_long_call dw e_dhp_entry dw e_cnp_rom_segment endm call_dhp_driver macro db e_long_call dw e_dhp_driver dw e_cnp_rom_segment endm baud_port equ 0ch ; port address of baud rate controller ; ; table to print out value of a nibble on the screen asciitab db '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F' ; porta_baud db 0 ; stored baud codes portb_baud db 0 start_porta_baud db 0 start_portb_baud db 0 data ends code segment public 'code' extrn comnd:near, dopar:near, atoi:near, prompt:near extrn sleep:near,statc:near, srchkw:near extrn msuinit:near, keybd:near ; in msuhp1.asm extrn keybdopen:near, keybdclose:near ; in msuhp1.asm extrn getkey:near ; in msuhp1.asm extrn clearlabels:near, labelsoftkeys:near ; in msuhp1.asm extrn displaylogoffkey:near, displaylogonkey:near ; in msuhp1 extrn pntchr:near, pntflsh:near assume cs:code, ds:data, es:nothing ; Clear the input buffer before sending a packet. CLRBUF PROC NEAR cmp repflg,0 ; doing replay? je clrb0 ; e => no replay ret ; don't clear if replaying clrb0: push ax ; need to save for CROSHAIR in msggri cli mov ax,offset source mov bufin,ax mov bufout,ax mov count,0 sti clrb1: call prtchr ; get a character jnc clrb1 ; until there aren't any more nop pop ax ret CLRBUF ENDP ; Common routine to clear to end-of-line CLEARL PROC NEAR push ax push dx mov dx,offset clreol mov ah,prstr int dos pop dx pop ax ret CLEARL endp ; Set the baud rate for the current port, based on the value ; in the portinfo structure. Returns carry clear. BAUDST PROC NEAR mov dx,offset bdtab ; baud rate table, ascii xor bx,bx ; help is the table itself mov ah,cmkey ; get keyword call comnd jc baudst1 ; c = failure push bx ; save result mov ah,cmeol ; get confirmation call comnd pop bx jc baudst1 ; c = failure mov si,portval mov ax,[si].baud ; remember original value mov [si].baud,bx ; set the baud rate call dobaud ; use common code clc baudst1:ret BAUDST ENDP ; on entrance bx has baud rate from bdtab dobaud proc near ; updated by [jan] to set baud mov ax,portval cmp ax,offset port1 ; using port 1? jne dobaud1 ; ne => not using port 1 mov al,1 ; port 1 set mov ah,bl ; baud code call set_baud ; set the baud rate ret dobaud1:mov al,2 ; set port 2 baud mov ah,bl ; ah has baud code call set_baud ret dobaud endp ; Send the break signal out data comm sendbl: ; long break (same as regular h sendbr: mov al,e_send_break ; regular break call dc_ioctl clc ; clear carry bit (stay in Connect) ret ; Set some data comm ioctl option. AL has function code dc_ioctl proc near push ax ; save regs push bx push cx push dx mov ah,8h mov tempbuf,ax mov dx,offset tempbuf mov ah,e_ioctl mov al,3 mov bx,prthnd mov cx,2 int dos pop dx ; restore regs pop cx pop bx pop ax ret dc_ioctl endp shomodem proc near mov ah,cmeol ; get a confirm call comnd jnc shomod00 ; nc => success ret ; get out if failure shomod00: cmp prthnd,0 ; Got a handle yet? jne shmod0 ; Yup just go on call opnprt ; Else 'open' the port shmod0: mov dx,offset msmsg1 ; say port is not ready mov bx,prthnd mov al,7 ; output status command mov ah,ioctl ; ask DOS to look for us int dos jc shmod1 ; c = call failed, device not ready or al,al jz shmod1 ; not ready mov dx,offset msmsg2 ; say port is ready shmod1: mov ah,prstr int dos clc ret shomodem endp getmodem proc near mov al,0 ret getmodem endp ; Put the char in AH to the serial port. This assumes the ; port has been initialized. Should honor xon/xoff. Skip returns on ; success, returns normally if the character cannot be written outchr proc near push cx or ah,ah ; sending a null? jz outch2 ; z = yes xor cx,cx ; clear counter cmp ah,flowoff ; sending xoff? jne outch1 ; ne = no mov xofsnt,false ; supress xon from chkxon buffer routine outch1: cmp xofrcv,true ; Are we being held? jne outch2 ; No - it's OK to go on loop outch1 ; held, try for a while mov xofrcv,false ; timed out, force it off and fall thru outch2: push dx ; Save register mov al,ah ; Parity routine works on AL call dopar ; Set parity appropriately ; Begin revised output routine mov byte ptr temp,al ; put data there cmp prthnd,0 ; Got a handle yet? jne outch3 ; Yup just go on call opnprt ; Else 'open' the port outch3: push bx mov bx,prthnd ; port handle mov cx,1 ; one byte to write mov dx,offset temp ; place where data will be found mov ah,write2 ; dos 2 write to file/device int dos pop bx ; restore registers pop dx pop cx clc ret outchr endp ; Get a file handle for the communications port. Use DOS call to get the ; next available handle. If it fails, ask user what value to use (there ; should be a predefined handle for the port, generally 3). The open ; will fail if the system uses names other than "COM1" or "COM2". opnprt proc near mov al,flags.comflg dec al ; flags.comflg is 1 for com1, 2 for com2 mov ah,0 push si mov si,ax shl si,1 ; double index mov dx,prttab[si] pop si mov ah,open2 mov al,2 int dos jnc opnpr2 mov ah,prstr ; it didn't like the string mov dx,offset erms41 int dos ret opnpr2: mov prthnd,ax ; Call succeeded call set_port_param ; set appropriate parameters call serini ; set appropriate parameters ret opnprt endp ; This routine blanks the screen. CMBLNK PROC NEAR ; This is stolen from the IBM example push ax push dx mov ah,prstr mov dx,offset blank int dos pop dx pop ax ret CMBLNK ENDP LOCATE PROC NEAR mov dx,0 ; Go to top left corner of screen jmp poscur ; Go and move the cursor LOCATE ENDP ; To get the baud, it is likely we would need to ; directly access the UART. Not implemented. GETBAUD PROC NEAR ret GETBAUD ENDP ; Carry set if no character available at the port. If carry clear, ; returns with char in al, # of chars in buffer in dx. PRTCHR PROC NEAR cmp repflg,0 ; doing replay? je prtch0 ; e=> not doing replay jmp getrepchr ; get replay character if in replay prtch0: push bx push cx push si cmp prthnd,0 ; have a handle yet? jne prtch1 ; yes, keep going call opnprt prtch1: cmp count,0 ; no characters? jne prtch2 ; no, go fill buffer mov bx,prthnd mov al,rdchan mov ah,ioctl mov dx,offset source ; buffer to read into mov cx,20 ; read 20 characters at a time ; More characters cause problems for ; early firmware versions int dos jc prtch4 ; c = error mov count,ax ; reset count mov keydelay, -1 ; read keyboard next go around mov dx,ax ; needed to obey rules or ax,ax jz prtch4 ; still no chars mov bufout,offset source ; this is output ptr prtch2: dec count mov dx,count ; return count in dx mov si,bufout cld lodsb ; get character mov bufout,si ; update ptr prtch3: pop si pop cx pop bx clc ; clc if there is a character ret ; exit success prtch4: pop si pop cx pop bx stc ; set carry if no characters ret PRTCHR ENDP ; IHOSTS - Initialize the host by sending XON, or equivalent, and enter the ; cycle of clear input buffer, wait 1 second, test if buffer empty then exit ; else repeat cycle. Requires that the port be initialized before hand. ; Ihosts is used by the local send-file routine just after initializing ; the serial port. ; 22 March 1986 [jrd] IHOSTS PROC NEAR push ax ; save the registers push bx push cx push dx mov bx,portval ; port indicator mov ax,[bx].flowc ; put Go-ahead flow control char in ah or ah,ah ; don't send null if flow = none jz ihosts1 ; z = null call outchr ; send it (release Host's output queue) ihosts1:call clrbuf ; clear out interrupt buffer pop dx ; empty buffer. we are done here pop cx pop bx pop ax ret IHOSTS ENDP ; IHOSTR - initialize the remote host for our reception of a file by ; sending the flow-on character (XON typically) to release any held ; data. Called by receive-file code just after initializing the serial ; port. 22 March 1986 [jrd] IHOSTR PROC NEAR push ax ; save regs push bx push cx mov bx,portval ; port indicator mov ax,[bx].flowc ; put Go-ahead flow control char in ah or ah,ah ; don't send null if flow = none jz ihostr1 ; z = null call outchr ; send it (release Host's output queue) ihostr1:pop cx pop bx pop ax ret IHOSTR ENDP DTRLOW PROC NEAR ; Global proc to Hangup the Phone by making mov ah,cmline ; allow text to be able to display help mov bx,offset rdbuf ; dummy buffer mov dx,offset hnghlp ; help message call comnd ; get a confirm jnc dtrlow1 ; nc => success ret ; get out if failure dtrlow1:call serhng ; drop DTR and RTS writestring hngmsg ; tell user of success clc ; success ret DTRLOW ENDP ; Hang up the Phone. Similar to SERRST except it just forces DTR and RTS low ; to terminate the connection. 29 March 1986 [jrd] ; Calling this twice without intervening calls to serini should be harmless. ; Returns normally. Implemented by [jan]. SERHNG PROC NEAR mov al,5 ; modem disconnect code call dc_ioctl clc ; stay in connect mode ret SERHNG ENDP ; Position the cursor according to contents of DX POSCUR PROC NEAR push ax ; save regs push dx push di push es mov ax,ds mov es,ax ; address data segment cld mov di,offset colno mov al,dl ; column call nout mov al,'c' stosb mov al,dh ; row call nout mov al,'Y' stosb mov al,'$' stosb mov dx,offset movcur mov ah,prstr int dos ; print the sequence pop es ; restore regs pop di pop dx pop ax ret POSCUR ENDP NOUT PROC NEAR cbw ; extend to word div byte ptr ten ; divide by 10 or al,al ; any quotient? jz nout1 ; no, forget this push ax ; save current result call nout ; output high order pop ax ; restore nout1: mov al,ah ; get digit add al,'0' ; make printable stosb ret ; put in buffer and return NOUT endp ; Write a line in inverse video at the bottom of the screen... ; the line is passed in dx, terminated by a $. Returns normally. putmod proc near push dx ; preserve message mov dx,24 * 100H ; line 24 call poscur mov dx,offset invseq ; put into inverse video mov ah,prstr int dos pop dx int dos mov dx,offset nrmseq ; normal videw int dos ret ; and return putmod endp ; Clear the mode line written by putmod. Returns normally. clrmod proc near mov dx,24 * 100H call poscur call clearl ret clrmod endp ; Put a help message one the screen in reverse video. Pass ; the message in AX, terminated by a null. Returns normally. ; The message is put wherever the cursor currently is located. puthlp proc near push ax ; save some regs push si push dx push ax mov ah,prstr ; Leave some room before the message mov dx,offset crlf int dos pop si ; Put message address here puth0: mov ah,prstr mov dx,offset invseq ; Put into reverse video int dos mov ah,prstr mov dx,offset ivlseq ; Make line inverse video int dos cld puth1: lodsb cmp al,0 ; Terminated with a null je puth2 mov dl,al mov ah,conout int dos cmp al,lf ; Line feed? je puth0 ; e = yes, clear the next line jmp puth1 ; else, just keep on writing puth2: mov dx,offset crlf mov ah,prstr int dos mov dx,offset nrmseq ; Normal video int dos pop si pop dx pop ax ret puthlp endp ; Perform a delete. DODEL PROC NEAR push ax push dx mov ah,prstr mov dx,offset delstr ; Erase character int dos pop dx pop ax ret DODEL ENDP ; Perform a Control-U. CTLU PROC NEAR push ax push dx mov ah,prstr mov dx,offset clrlin int dos pop dx pop ax ret CTLU ENDP COMS PROC NEAR mov dx,offset comptab ; comms port table mov bx,0 ; use keywords as help mov ah,cmkey ; parse keyword call comnd jnc coms1 ; nc => success ret ; get out if failure coms1: push bx mov ah,cmeol call comnd ; Get a confirm jc comx ; didn't get a confirm call serrst ; close existing port before opening pop bx ; the new one mov flags.comflg,bl ; Set the comm port flag cmp flags.comflg,1 ; Using Com 1? jne coms2 ; ne = no mov portval,offset port1 call serini ; initialize new port ret coms2: mov portval,offset port2 ; use Com2 call serini ; initialize port ret comx: pop bx ret COMS ENDP VTS PROC NEAR ; Set Term code mov dx, offset termtb mov bx,0 mov ah,cmkey call comnd jnc vts1 ; nc => success ret ; return if failure vts1: push bx mov ah,cmeol call comnd jnc vts2 ; nc=> success pop bx ret ; return if failure vts2: pop bx ; bl has number from termtb mov di,offset dc_status cmp bl,eightbitnum ; doing 8 bits? jne vts3 mov [di].eightbit,true call set_port_param ; set port parameters clc ret vts3: cmp bl,sevenbitnum ; doing 7 bits? jne vts4 ; ne => not 7 bits mov [di].eightbit,false call set_port_param ; set port parameters clc ret vts4: cmp bl,transonnum ; transparency on? jne vts5 mov [di].transparent,true call set_port_param ; set port parameters clc ret vts5: cmp bl,transoffnum ; transparency off? jne vts6 mov [di].transparent,false call set_port_param ; set port parameters clc ret vts6: cmp bl,rawonnum ; make port raw? jne vts7 mov [di].raw,true call set_port_param ; set port parameters clc ret vts7: cmp bl,rawoffnum ; cook the port? jne vts7a mov [di].raw,false call set_port_param ; set port parameters clc ret vts7a: cmp bl,tekonnum ; enable tek? jne vts7b ; ne => don't enable and denyflg,not tekxflg ; clear tekx bit mov tekbyte,bl ; for status display clc ret vts7b: cmp bl,tekoffnum ; disable tek jne vts8 ; ne => don't disable or denyflg,tekxflg ; set tek deny bit mov tekbyte,bl ; for status display clc ret vts8: cmp bl,ttgenrc ; hp150 emulation selected? jne vts9 mov flags.vtflg,bl ; set emulator type clc ret vts9: cmp bl,tttek ; tek emulation selected? jne vts10 mov flags.vtflg,bl vts10: clc ret ; success VTS ENDP VTSTAT PROC NEAR ; For Status display mov bx,offset vtstbl ; table of things to show jmp statc ; common status code VTSTAT ENDP ; Save the screen to a buffer and then append buffer to a disk file. [jrd] ; Default filename is Kermit.scn; actual file can be a device too. Filename ; is determined by mssset and is passed as pointer dmpname. DUMPSCR PROC NEAR ; Dumps screen contents to a file. Just Beeps here call beep ret DUMPSCR ENDP lclini proc near saveregs call read_baud ; use firmware to read baud rates mov lclexit,offset lclose ; routine to call when closing mov prtrdy,true ; port is ready mov flags.vtflg,0 ; no terminal emulation. [jrd] mov prthnd,0 ; no port handle yet. [jrd] call msuinit ; initialize keyboard module msugen call serini ; initialize port restoreregs ret lclini endp ; Wait for the # of milliseconds in ax, for non-IBM compatibles. ; Thanks to Bernie Eiben for this one. pcwait proc near mov cx, 180 ; hp150 has effective clock of only 3.6 MHz!!! pcwai1: sub cx,1 ; inner loop takes 20 clock cycles jnz pcwai1 dec ax ; outer loop counter jnz pcwait ; wait another millisecond ret pcwait endp ; Initialization for using serial port. Returns normally. ; Attempts to put port device in binary mode. [jrd] SERINI PROC NEAR cld ; Do increments in string operations cmp prthnd,0 ; Got a handle yet? jne serin0 push bx call opnprt ; Else 'open' the port pop bx serin0: push bx mov bx,portval ; get port [jrd] mov parmsk,0ffh ; parity mask, assume parity is None cmp [bx].parflg,parnon ; is it None? je serin1 ; e = yes mov parmsk,07fh ; no, pass lower 7 bits as data serin1: mov bx,[bx].flowc ; get flow control chars mov flowoff,bl ; xoff or null mov flowon,bh ; xon or null pop bx clc ; carry clear for success ret SERINI ENDP SERRST PROC NEAR push bx ; save reg push di mov bx,prthnd cmp bx,0 ; none there? je serrs6 ; no, don't try to close ; return the port to the orignal status mov bx, prthnd ; handle call cookedon ; cook the port first mov al, e_port1 ; assume port 1 mov bx, offset port1 cmp portval, bx ; are we using port 1? je serrs2 mov al, e_port2 ; using port 2 serrs2: call get_config_values ; read configuration di points to work_config mov al, 1 ; assume 7 bit mode test [di].dc_bool2, 2 ; if bit2 set => 7 bit jnz serrs3 ; nx => yes 7 bit mov al,2 ; 2 for 8 bit serrs3: call dc_ioctl ; update the number of bits mov al, 4 ; disable data comm transparency call dc_ioctl mov bx, prthnd ; port handle in bx for close mov ah,close int dos ; close handle mov prthnd,0 ; the port is now closed serrs6: pop di pop bx ret ; All done SERRST ENDP ; Generate a short beep. BEEP PROC NEAR mov dl,bell mov ah,conout int dos ret BEEP ENDP ; Dumb terminal emulator. Doesn't work too well above 1200 baud (and ; even at 1200 baud you sometimes lose the first one or two characters ; on a line). Does capture (logging), local echo, debug display, tests ; for printer/logging device not ready. 27 Sept 86 [jrd]. term proc near mov argadr,ax ; save argument ptr mov si,ax ; this is source mov di,offset ourarg ; place to store arguments push es ; save register push ds pop es ; make es point to datas segment mov cx,size termarg cld rep movsb ; copy into our arg blk pop es ; recover reg mov ax,ourarg.captr ;;; mov captrtn,ax ; buffer capture routine call pntflsh ; flush printer buffer mov keydelay,0 ; initizize keyboard counter [jan] mov parmsk,0ffh ; parity mask, assume parity = None call keybdopen ; turn on keycode mode call labelsoftkeys call displaylogkey ; decide whehter to display logging softkey cmp flags.vtflg,tttek ; in tektronix emulation? jne term0 ; ne=> doing alpha call tekini ; initialize emulator term0: mov parmsk,0ffh ; 8 bit parity by default cmp ourarg.parity,parnon ; is parity None? je term1 ; e = yes, keep all 8 bits mov parmsk,07fh ; else keep lower 7 bits term1: cmp prtrdy,false ; ready to read port? jne term2 ; ne = yes mov kbdflg,'C' ; so we exit connect mode mov prtrdy,true ; get ready for next connect jmp term5 ; get out term2: call portchr ; get char from port, mask parity jnc short term4 ; nc = no char, go on call stringchek ; check the string for escape sequence jnc short term4 ; nc => no key to show term3: call outtty ; display and capture char term4: inc keydelay ; increment counter mov ah,keydelay ; move into ah and ah,15 ; clear high bits and read keyboard jne term1 ; once each 16 reads of serial port call keybd ; call keyboard translator in msu jnc term1 ; nc = no char or have processed it term5: ; carry set = quit Connect mode call pntflsh ; flush printer buffer call clearlabels ; blank softkey labels call keybdclose ; turn off keycode mode writestring alpha_disp ; make sure we are in alpha upon exit writestring alpha_on ; turn on alpha writestring tek_off ; turn off tek call test_baud_change ; check for baud change call cptdmp ; empty the capture buffer ret term endp ; put the character in al to the screen, do capture and printing, ; does translation for Set Input command. ; Adapted from msyibm.asm [jrd] outtty proc near test flags.remflg,d8bit ; keep 8 bits for displays? jnz outnp8 ; nz = yes, 8 bits if possible and al,7fh ; remove high bit outnp8: cmp rxtable+256,0 ; is translation off? je outnp7 ; e = yes, off push bx ; Translate incoming char mov bx,offset rxtable ; address of translate table xlatb ; new char is in al pop bx outnp7: cmp logflag,true ; are we logging? jne outnoc ; ne => no, forget logging push ax ; save char call captrtn ; give it captured character pop ax ; restore character and keep going outnoc: test anspflg,prtscr ; should we be printing? jz outnop ; no, keep going call pntchr ; queue char for printer jnc outnop ; nc = successful print push ax call beep ; else make a noise and call trnprs ; turn off printing pop ax outnop: cmp flags.vtflg,0 ; emulating a terminal? jnz outnop1 ; nz = yup, go do something smart test ourarg.flgs,trnctl ; debug? if so use dos tty mode jz outnp4 ; z = no mov ah,conout cmp al,7fh ; Ascii Del char or greater? jb outnp1 ; b = no je outnp0 ; e = Del char push ax ; save the char mov dl,7eh ; output a tilde for 8th bit int dos pop ax ; restore char and al,7fh ; strip high bit outnp0: cmp al,7fh ; is char now a DEL? jne outnp1 ; ne = no and al,3fH ; strip next highest bit (Del --> '?') jmp outnp2 ; send, preceded by caret outnp1: cmp al,' ' ; control char? jae outnp3 ; ae = no add al,'A'-1 ; make visible outnp2: push ax ; save char mov dl,5eh ; caret int dos ; display it pop ax ; recover the non-printable char outnp3: mov dl,al int dos ret outnp4: ;cmp al,bell ; bell (Control G)? ;jne outnp5 ; ne = no ;jmp beep ; use short beep, avoid char loss outnop1: outnp5: mov dl,al ; write without intervention mov ah,6 ; direct console i/o int dos ; else let dos display char ret ; and return outtty endp ; send the character in al out to the serial port; handle echoing. ; Can send an 8 bit char while displaying only 7 bits locally. outprt proc near test ourarg.flgs,lclecho ; echoing? jz outpr1 ; z = no, forget it push ax ; save char call outtty ; print it pop ax ; restore outpr1: mov ah,al ; this is where outchr expects it call outchr ; output to the port ret outprt endp ; Get a char from the serial port manager ; returns with carry on if a character is available portchr proc near call prtchr ; character at port? jnc portc1 ; nc = yes there is a character portc0: clc ; no carry -> no character ret ; and return portc1: and al,parmsk ; apply 8/7 bit parity mask stc ; have a character ret ; and return portchr endp ;; keyboard translator action routines, system dependent, called from msugen. ; These are invoked by a jump instruction. Return carry clear for normal ; processing, return carry set to exit Connect mode (kbdflg has transfer char) chrout proc near cmp repflg,0 ; in replay mode? je chrout1 ; e=> not doing replay jmp repchrout ; display the replay character chrout1:call outprt ; put char in al to serial port clc ; stay in Connect mode ret chrout endp trnprs: push ax ; toggle Copy screen to printer test anspflg,prtscr ; should we be printing? jnz trnpr2 ; nz = yes, its on and going off mov ah,ioctl mov al,7 ; get output status of printer push bx mov bx,prnhand ; file handle for system printer int dos pop bx jc trnpr1 ; c = printer not ready cmp al,0ffh ; Ready status? je trnpr2 ; e = Ready trnpr1: call beep ; Not Ready, complain jmp short trnpr3 ; and ignore request trnpr2: xor anspflg,prtscr ; toggle print flag trnpr3: pop ax clc ret displaylogkey proc near ; display logging softkey? test flags.capflg, logses ; session logging enables? jz displaylogkey3 ; z= no, forget it cmp logflag, true ; are we logging? jne displaylogkey1 ; ne => not logging call displaylogoffkey ; off key if capturing jmp displaylogkey2 ; make a good exit displaylogkey1: call displaylogonkey ; show log on function key displaylogkey2: clc ret displaylogkey3: mov logflag, false ; not logging clc ret displaylogkey endp klogtog proc near ; toggle session logging key test flags.capflg, logses ; session logging enables? jz klogtogn ; z= no, forget it cmp logflag, true ; are we capturing? jne klogtog1 ; ne => not logging mov logflag, false ; turn off loggin push bx mov bx, argadr and [bx].flgs, not capt ; tell kermit we are stopping capture and ourarg.flgs, not capt ; turn off local capture flag pop bx ; restore the register call displaylogkey ; turn on appropriate log key call cptdmp ; dump the capture buffer to file jmp klogtog2 klogtog1: mov logflag, true ; turn on logging push bx mov bx, argadr or [bx].flgs, capt ; tell kermit we are resuming capture or ourarg.flgs, capt ; turn on local capture flag pop bx ; restore the register call displaylogkey ; turn on log off key klogtog2: clc ret klogtogn: mov logflag, false ; not logging so turn off flag clc ret klogtog endp snull: mov ah,0 ; send a null call outchr ; send without echo or logging clc ret kdos: mov al,'P' ; Push to DOS jmp short cmdcom cstatus: mov al,'S' ; these commands exit Connect mode jmp short cmdcom cquit: mov al,'C' jmp short cmdcom cquery: mov al,'?' jmp short cmdcom cmdcom: mov kbdflg,al ; pass char to msster.asm via kbdflg stc ; say exit Connect mode ret ;; end of action routines ; set comm port parameters based on dc_status structure set_port_param proc near push di cmp prthnd,0 ; got a handle yet jne set_port_param1 ; ne = yes call opnprt jmp set_port_param5 ; opnprt calls this so don't repeat set_port_param1: mov di,offset dc_status cmp [di].eightbit,true ; doing 8 bit? je set_port_param2 ; e=> yes, doing 8 7 bit mov eightflg,sevenbitnum ; so status knows we have seven bits mov al,1 ; dc_ioctl code for 7 bit call dc_ioctl jmp set_port_param2a ; check transparent set_port_param2: mov eightflg,eightbitnum ; so status knows we have eight bits mov al,2 ; code for 8 bit call dc_ioctl set_port_param2a: cmp [di].transparent,true ; in transparency mode? je set_port_param3 ; e=> yes mov transparentflg,transoffnum ; so status knows transparency off mov al,4 ; code to disable transparency call dc_ioctl jmp set_port_param3a ; check raw/cooked situation set_port_param3: mov transparentflg,transonnum ; so status knows transparency on mov al,3 ; code to enable transparency call dc_ioctl set_port_param3a: cmp [di].raw,true ; raw mode set? je set_port_param4 ; e => raw on mov rawflg,rawoffnum ; so status knows we're cooked mov bx,prthnd ; cooked on needs port handle call cookedon jmp set_port_param5 ; done set_port_param4: mov rawflg,rawonnum ; tell status port is raw mov bx,prthnd ; port handle for raw on call rawon set_port_param5: pop di clc ret set_port_param endp ;check string to see if we need to do something special stringchek proc near cmp stringchekcnt,0 ; nobody in yet? jne stringchek1 ; ne => already have characters cmp al,escape ; is this escape? je stringchek1 ; it is escape, so go and process cmp al,escape+80h ; in case parity is odd je stringchek1 ; process escape stc ; display the character ret ; return quickly if nothing to do stringchek1: ; here is escape already in saveregs and al,07fh ;strip high bit mov bx,stringchekcnt mov stringchekbuff[bx],al ;put character in buffer inc stringchekcnt ;one more character in buffer call stringtest ; does the string in stringchekbuff match? cmp match,0 ; 0 means no match je stringchek2 mov si,match ; here means we have a match shl si,1 ; multiply by 2 dec si dec si ; 1=0, 2=1 etc call disptab[si] ; call appropriate function call stringbuffplay ; play back the buffer clc ; don't display jmp stringchek3 ; return and don't display character stringchek2: clc ; don not display cmp matchsofar,true ; do we have a match so far je stringchek3 ; e=true , get out mov playem,true call stringbuffplay ; clean out the buffer clc ; don't display character stringchek3: restoreregs ret stringchek endp ;test to see if input string is a match to toggle terminal [jan] ; stringtab gives addresses of 0 terminated strings ; teststring in stringchekbuff ; numstrings is the number to checked ; matchsofar will have be true if there is a possilbe match ; match will be non-zero 1, 2, 3 indicating number of match if a match ; if no match yet, match will be 0 ; severaal registers get destroyed stringtest proc near mov matchsofar,false ; assume no match mov match,0 ; no match xor si,si ; pointer to string tab dec si dec si ; step back 1 item mov cx,0 ; cx points to number of string strtst1: inc cx ; strings number cmp cx,numstrings ; done parsing table? ja strtst5 ; we're done, get out of here mov di,offset stringchekbuff inc si inc si ; point to next item mov bx,stringtab[si] ; offset of string strtst2: mov al,[di] ; stringchekbuff in al mov ah,[bx] ; string element to test in ah cmp al,0 ; end of stringchekbuff jne strtst2a ; ne=> not at end of buffer mov matchsofar,true ; we have a match so far jmp strtst5 ; return to caller strtst2a: cmp ah,0 ; at end of string? je strtst1 ; failure, go to next string cmp ah,al ; match? jne strtst1 ; no match, on to next string ; here if match mov ah,[bx+1] ; next byte from string cmp ah,0 ; are we done with string? je strtst3 ; e => yes, a match inc bx ; next element in string inc di ; next character in stringchekbuff jmp strtst2 ; check next item in string strtst3: ; here if we have a match mov match,cx mov matchsofar,true strtst5:ret stringtest endp ;play back characters in string buffer ..called by stringchek stringbuffplay proc near xor bx,bx mov cx,stringchekcnt stringbuffplay1: mov al,stringchekbuff[bx] cmp playem,true ; playback characters? jne stringbuffplay2 ; ne = no don't play back push bx ; save index push cx ; save count call outtty ; print the character pop cx ; restore count pop bx ; restore index stringbuffplay2: mov stringchekbuff[bx],0 ; set to 0 inc bx ; point to next character loop stringbuffplay1 ; repeat until buffer is empty mov stringchekcnt,0 ; now no characters in buffer ret stringbuffplay endp ignoretek proc near ; ignore this escape sequence in tek mode mov playem,false cmp flags.vtflg,tttek ; are in in tek emulation je ignoretek1 ; e=yes do not play back mov playem,true ignoretek1:ret ignoretek endp ignoreall proc near ; always ignore this escape sequence mov playem,false call beep ; let user know of illegal sequence ret ignoreall endp totekplay proc near ; turn on tektronix mov playem,true ; play back characters jmp totek totekplay endp toteknoplay proc near mov playem,false jmp totek toteknoplay endp totek proc near ; turn on tektronix test denyflg,tekxflg ; tek auto entry enabled? jz totek1 mov playem,true ; play back characters ret totek1: cmp flags.vtflg,tttek ; already doing tek je totek2 call termtog ; toggle to tektronix totek2: ret totek endp leavetek proc near ; turn off tektronix mov playem,false ; don't play back characters test denyflg,tekxflg ; tek auto entry/exit enabled? jz leavetek1 mov playem,true ; play back characters ret leavetek1: cmp flags.vtflg,tttek ; already doing tek jne leavetek2 ; ne => doing alpha so ignore call termtog ; toggle to alpha leavetek2:ret leavetek endp getrepchr proc near ; get replay character for file mov ah,readf2 ; read from replay file mov bx,diskio.handle mov cx,1 ; read 1 character mov dx,offset rdbuf ; to this buffer int dos jc getrepchr1 ; c => failure cmp ax,cx ; read the byte? jne getrepchr1 mov al,rdbuf ; al has character clc ; character available in al ret getrepchr1: call beep ; announce file is done call beep call waitkey ; wait for a key to be pressed mov prtrdy,false ; so we exit connect mode stc ret ; no character available getrepchr endp repchrout proc near ; process key in al while replaying and al,7fh ; strip parity repchrout1: cmp al,'C'-40h ; Control C?(to exit playback mode) je repchrout3 ; e=> yes, return failure cmp al,XOFF ; user wants to stop? jne repchrout2 ; ne => ok to continue call waitkey ; wait and get a key jmp repchrout1 ; now process this key repchrout2: clc ; return success ret repchrout3: mov prtrdy,false ; exit terminal stc ; exit connect mode ret repchrout endp termtog proc near ; toggle terminal type [jan] cmp flags.vtflg,tttek ; doing tek emulation ? jne termtog1 ; ne means doing tek writestring tek_off ; turn off tek writestring alpha_disp ; turn on alpha writestring alpha_on ; and turn on the alpha mov flags.vtflg,ttgenrc ; turn on alpha display clc ret termtog1:mov flags.vtflg,tttek ; turn on tek display writestring alpha_off ; turn off alpha writestring tek_disp writestring tek_on ; and turn on the tek clc ; do not exit Connect mode ret ; stay in connect mode termtog endp kclrscn proc near ; clear the screen cmp flags.vtflg,tttek ; doing tek emulation je kclrscn1 ; e=> yes writestring alpha_clear ; clear the alpha clc ; stay in connect mode ret ; return to caller kclrscn1:writestring tek_clear ; clear the tektronix clc ; stay in connect mode ret kclrscn endp waitkey proc near ; wait for a key to be pressed waitkey0:call getkey ; get a key; carry set => no key; code in ax jc waitkey0 ; repeat until its pressed ret waitkey endp tekini proc near ; initialize tek emulator writestring alpha_off writestring tek_disp ; enable tektronix writestring tek_on ; turn on tek ret tekini endp toterminal proc near ; go to firmware terminal mode cmp dosnum,dos211 ; dos 2.11 or above? jae toterminal1 ; ae=> ok to go to terminal mov ah,2 mov dl,7 int dos ; ring the bell clc ; stay in connect mode ret toterminal1: call clearlabels ; blank softkey labels call keybdclose ; get out of keycode writestring to_term_msg mov ax,1750 call pcwait ; 1 3/4 second time to read message mov bx,offset agiosbuff mov word ptr [bx],26 ; function code to get into terminal mov ax,4403h ; io control write mov bx,1 ; console handle mov cx,2 ; 2 bytes in buffer mov dx,offset agiosbuff int dos ; now in terminal mode call labelsoftkeys ; turn keys on when we return call keybdopen ; back to keycode mode clc ; stay in connect mode ret ; back to terminal toterminal endp cookedon proc near ; cook handle in bx push ax push dx ; save registers push bx ; save handle mov ax,4400h ; get device information int dos xor dh,dh ; clear high byte and dl,0dfh ; clear raw bit without changing other bits mov ax,4401h ; put device information pop bx ; restore handle int dos ; turn off raw mode pop dx ; restore registers pop ax clc ; always returns success ret cookedon endp rawon proc near push ax push dx ; save registers push bx ; save handle mov ax,4400h ; get device information int dos xor dh,dh ; clear high byte or dl,20h ; set raw bit mov ax,4401h ; put device information pop bx ; restore handle int dos ; turn on raw mode pop dx pop ax ; restore registers clc ; always returns success ret rawon endp ;;;cptchr and cptdmp taken from msster to fix the problem ; of com buffer overflow with logging the session cptchr proc near ; session capture routine, char in al push di mov di,capbp ; buffer pointer mov byte ptr [di],al inc capbp pop di dec caplft ; decrement chars remaining jg cptch1 ; more room, forget this part call cptdmp ; dump the info cptch1: ret cptchr endp cptdmp proc near ; empty the capture buffer push ax push bx push cx push dx mov bx,sloghnd ; get file handle cmp bx,0 ; is file open? jle cptdm1 ; le = no, skip it push bx ; save handle mov bx,portval ; doing flow control? cmp [bx].floflg,0 ; e = no je cptdmp01 cmp xofsnt,true ; have we sent xoff? je cptdmp01 ; don't send it again mov ah,flowoff ; get the xoff or ah,ah ; null (no flow control?) jz cptdmp01 call outchr ; send xoff to port mov xofsnt,true ; remember we've sent it cptdmp01:pop bx ; restore handle mov cx,cptsiz ; original buffer size sub cx,caplft ; minus number remaining jl cptdm2 ; means error jcxz cptdm1 ; z = nothing to do mov dx,offset capbuf ; the capture routine buffer mov ah,write2 ; write with filehandle int dos ; write out the block jc cptdm2 ; carry set means error mov capbp,offset capbuf mov caplft,cptsiz ; init buffer ptr & chrs left jmp short cptdm1 cptdm2: and flags.capflg,not logses ; so please stop capturing ; and targ.flgs,not capt ; so please stop capturing and ourarg.flgs, not capt ; so please stop capturing mov dx,offset capterr ; tell user the bad news mov ah,prstr int dos cptdm1: cmp xofsnt, true ; xoff sent jne cptdm02 mov ah,flowon ; get the xon or ah,ah ; null? jz cptdm02 call outchr ; send xon mov xofsnt,false ; remember we've sent it cptdm02:pop dx pop cx pop bx pop ax ret cptdmp endp test_baud_change proc near ; check if firmware baud changed mov al,e_port1 call get_config_values mov al,[di].dc_baud_rate cmp al,start_porta_baud ; baud rate changed by firmware (via user) je test_baud_change1 ; e = not changed call read_bauda ; redo port a baud test_baud_change1: mov al,e_port2 ; check if port 2 changed call get_config_values mov al,[di].dc_baud_rate cmp al,start_portb_baud je test_baud_change2 ; e = not changed call read_baudb ; read port b baud test_baud_change2: ret test_baud_change endp read_baud proc near call read_bauda ; read port 1 baud call read_baudb ; read port 2 baud ret read_baud endp read_bauda proc near ; read baud on port 1 and update port info mov al,e_port1 call get_config_values ; get port 1 configuration mov si,offset port1 mov di,offset work_config mov bl,[di].dc_baud_rate ; baud rate into bl mov start_porta_baud,bl ; remember startup baud mov portb_baud,bl ; remember startup baud mov di,offset ourbdtab ; translate hp baud into kermit code shl bl,1 ; multiply by 2 for 2 bytes per entry xor bh,bh mov bl,[di+bx+1] mov [si].baud,bx ; write baud in port 1 info ret read_bauda endp ; Read the port 2 status read_baudb proc near mov al,e_port2 call get_config_values ; get port 2 configuration mov si,offset port2 mov di,offset work_config mov bl,[di].dc_baud_rate ; baud rate into bl mov start_portb_baud,bl ; remember startup baud mov portb_baud,bl ; current baud on port b mov di,offset ourbdtab ; translate hp baud into kermit code shl bl,1 ; multiply by 2 since 2 bytes per entry xor bh,bh mov bl,[di+bx+1] mov [si].baud,bx ; write baud in port 2 info ret read_baudb endp ;;; read data comm configuration. taken off dc.asm from compuserve ;******************************************* ; ; Firmware Programming Notes: ; ; 1) The firmware has a modular structure and generally consists ; of a bunch of processing modules which all have a separate ; logical segment and a limited number of entry points ; (generally only one). ; 2) The desired processing is accessed by passing the required ; parameters and the proper function code on entry to a ; module. ; 3) A call to a procedure outside the logical module is always ; a long call and inter segment (logical segment). ; 4) Parameters for a call to a procedure outside the logical ; module are pushed on the stack. This includes the function ; code. The procedure called has the responsibility of ; cleaning up the stack. ; 5) The procedure called should always return status in AX. ; Registers BX, CX, and DX may also contain outputs. ; 6) The caller should always assume registers AX, BX, CX, and ; DX have been modified. The caller should always assume ; registers SI, DI, SP, BP, DS, ES, and SS are the same on ; return. ; 7) Calls to external procedures are made through jump tables ; at the beginning of each rom. Thus the application is ; insulated from re-releases of the HP150 firmware. ; ;******************************************* page; ;*************** GRYPHON DECLARATIONS ************ ; To simplify external linking to absolute firmware jump locations, ; we include the long calls as constants. Note that we still have ; some measure of ROM independence because we entry the routines ; through fixed jump tables at the start of the RAM. ; ;------------------------------------------- ; ; COMMENTS: ; 1) The bytes PREDEF_VALUES and BARREL_INDEX are used by ; configuration processing during normal operation where a ; configuration form is brought onto the screen. Their ; values can be set and then ignored. ; 2) The bytes DC_PORT through DC_RECV_PACE are the actual ; datacomm configuration values. ; 3) The word DC_DEVICE_TOKEN is used to access the datacomm ; device. ; ;------------------------------------------- ;******************************************* ; ; The data format for the datacomm configuration values are as ; follows: ; ; 1) DC_PORT= 2 (port 1) ; 11 (port 2) ; ; 2) DC_BOOL1 (a graphical representation follows) ; 3) DC_BOOL2 ; ; HP Point-to-Point Boolean Bit Positions ; ; 7 6 5 4 3 2 1 0 ; +-------+-------+-------+-------+-------+-------+-------+-------+ ; | 1 Stop| CS(CB)| SRR | RR(CF)| SRR | SR(CH)| Chk | ENQ | ; | Bit | Xmit | Invert| Recv | Xmit | | Parity| ACK | ; +-------+-------+-------+-------+-------+-------+-------+-------+ ; | TR(CD)| DM(CC)| | | | | 7 Data| Xmit | ; | | Xmit | | | | | Bits | Pace | ; +-------+-------+-------+-------+-------+-------+-------+-------+ ; ; DC_BOOL1: ; ; Bit 0: 0 = No 1 = Yes ; Bit 1: 0 = No 1 = Yes ; Bit 2: 0 = Lo 1 = Hi ; Bit 3: 0 = No 1 = Yes ; Bit 4: 0 = No 1 = Yes ; Bit 5: 0 = No 1 = Yes ; Bit 6: 0 = No 1 = Yes ; Bit 7: 0 = 2 Stop Bits 1 = 1 Stop Bit ; ; DC_BOOL2: ; ; Bit 0: 0 = None 1 = Xon/Xoff ; Bit 1: 0 = 8 Data Bits 1 = 7 Data Bits ; Bit 6: 0 = No 1 = Yes ; Bit 7: 0 = Lo 1 = Hi ; ; 4) DC_BAUD_RATE = 02H (110 Baud) ; 04H (150 Baud) ; 05H (300 Baud) ; 06H (600 Baud) ; 07H (1200 Baud) ; 0AH (2400 Baud) ; 0CH (4800 Baud) ; 0EH (9600 Baud) ; 0FH (19200 Baud) ; ; 5) DC_PARITY = 0 (Zeros) ; 1 (Ones) ; 2 (Even) ; 3 (Odd) ; 4 (None) ; ; 6) DC_CLOCK = 0 (INT CLOCK) ; 1 (EXT X1 CLOCK) ; 2 (EXT X16 CLOCK) ; ; 7) DC_ASTERISK = 0 (No Asterisk) ; 1 (DM Asterisk) ; 2 (RR Asterisk) ; 3 (Line Asterisk) ; 4 (CS Asterisk) ; ; 8) DC_RECV_PACE = 0 (No Recv Pace) ; 1 (Xon/Xoff Recv Pace) ; 2 (TR(CD) Recv Pace) ; ;******************************************* ; ; ;------------------------------------------- ; ; PROCEDURE NAME: GET_CONFIG_VALUES ; ; FUNCTION: ; 1) Specify a block of configuration parameters to be obtained ; by config processing. The parameters define how datacomm ; is configured. ; 2) Config processing will get the data out of NVRAM. The ; values reflect the current configuration of the 150. ; 3) The data is written into the data area supplied by the ; caller and is in the format used by the datacomm driver. ; ; INPUTS: ; 1) DS - segment of CONFIGURATION_DATA_AREA ; 2) DI - offset of CONFIGURATION_DATA_AREA ; ; OUTPUTS: ; The configuration data area will have all the necessary ; values needed to specify the datacomm configuration. These ; can be modified so when they are passed to the datacomm ; driver, the new configuration will take effect. ; ; REGISTERS MODIFIED: ax, bx, cx, dx ; ;------------------------------------------- GET_CONFIG_VALUES proc near mov readid,e_port1_read mov saveid,e_port1_save cmp al,e_port1 je init90 mov readid,e_port2_read mov saveid,e_port2_save init90: mov di,offset work_config ;---------------------------------------- ; Initialize the variables of the config data area required ; by config processing. ;---------------------------------------- mov [di].PREDEF_VALUES,3 mov [di].BARREL_INDEX,6 mov ax,readid mov [di].DC_PORT,al ;---------------------------------------- ; Get the datacomm configuration values. ;---------------------------------------- mov ah,al ; Port X config type in AH mov al,4 ; full duplex, hardwired form. push ax mov ax,0201h ; 01 -> Personality ID push ax ; C02 -> Config values are required. push ds ; segment of CONFIGURATION_DATA_AREA push di ; pointer to start of data area lea ax,[di].DC_PORT ; pointer to start of config values push ax mov ax,3 ; function code for CNP_GET_DEV_CONFIG push ax CALL_CNP_ENTRY mov ax,saveid mov [di].dc_port,al ret GET_CONFIG_VALUES endp ; Set baud port (1 or 2) in al, Kermit baud code from bdtab in ah. ; First translate Kermit baud into HP baud set_baud proc near mov dx,ax ; save baud and port mov di,offset ourbdtab1 mov bl,ah ; put baud code in bl xor bh,bh ; bh=0 for indexing shl bl,1 ; x2 since two bytes per baud entry mov al,[di+bx+1] ; al now has hp baud code cmp dl,1 ; is it port 1? je set_baud1 ; e = yes mov portb_baud,al ; save it mov cl,4 shl al,cl ; port b in left nibble or al,porta_baud ; port a baud in right nibble out baud_port,al ; write the port a and port b baud clc ; success ret set_baud1: ; set port 1 baud mov porta_baud,al ; save the baud mov dl,portb_baud mov cl,4 shl dl,cl or al,dl ; port a in right nibble , port b in left nibble out 0ch,al ; write the port a and port b baud clc ; success ret set_baud endp lclose proc near ; this gets called when kermit quits mov al,e_port1 ; reset baud to match firmware values call get_config_values mov al,[di].dc_baud_rate ; port a baud rate push ax ; save this baud mov al,e_port2 call get_config_values mov bl,[di].dc_baud_rate ; port 2 baud rate mov cl,4 shl bl,cl ; port b baud in left nibble pop ax ; al has port a baud or al,bl ; both bauds in al out baud_port,al ; write the baud rate ret lclose endp code ends end